/**
 * Copyright (c) 2006-2015, JGraph Ltd
 * Copyright (c) 2006-2015, Gaudenz Alder
 */
var mxCellPath =
{
    /**
     * Class: mxCellPath
     *
     * Implements a mechanism for temporary cell Ids.
     *
     * Variable: PATH_SEPARATOR
     *
     * Defines the separator between the path components. Default is ".".
     */
    PATH_SEPARATOR: '.',

    /**
     * Function: create
     *
     * Creates the cell path for the given cell. The cell path is a
     * concatenation of the indices of all ancestors on the (finite) path to
     * the root, eg. "0.0.0.1".
     *
     * Parameters:
     *
     * cell - Cell whose path should be returned.
     */
    create: function (cell) {
        var result = '';

        if (cell != null) {
            var parent = cell.getParent();

            while (parent != null) {
                var index = parent.getIndex(cell);
                result = index + mxCellPath.PATH_SEPARATOR + result;

                cell = parent;
                parent = cell.getParent();
            }
        }

        // Removes trailing separator
        var n = result.length;

        if (n > 1) {
            result = result.substring(0, n - 1);
        }

        return result;
    },

    /**
     * Function: getParentPath
     *
     * Returns the path for the parent of the cell represented by the given
     * path. Returns null if the given path has no parent.
     *
     * Parameters:
     *
     * path - Path whose parent path should be returned.
     */
    getParentPath: function (path) {
        if (path != null) {
            var index = path.lastIndexOf(mxCellPath.PATH_SEPARATOR);

            if (index >= 0) {
                return path.substring(0, index);
            }
            else if (path.length > 0) {
                return '';
            }
        }

        return null;
    },

    /**
     * Function: resolve
     *
     * Returns the cell for the specified cell path using the given root as the
     * root of the path.
     *
     * Parameters:
     *
     * root - Root cell of the path to be resolved.
     * path - String that defines the path.
     */
    resolve: function (root, path) {
        var parent = root;

        if (path != null) {
            var tokens = path.split(mxCellPath.PATH_SEPARATOR);

            for (var i = 0; i < tokens.length; i++) {
                parent = parent.getChildAt(parseInt(tokens[i]));
            }
        }

        return parent;
    },

    /**
     * Function: compare
     *
     * Compares the given cell paths and returns -1 if p1 is smaller, 0 if
     * p1 is equal and 1 if p1 is greater than p2.
     */
    compare: function (p1, p2) {
        var min = Math.min(p1.length, p2.length);
        var comp = 0;

        for (var i = 0; i < min; i++) {
            if (p1[i] != p2[i]) {
                if (p1[i].length == 0 ||
                    p2[i].length == 0) {
                    comp = (p1[i] == p2[i]) ? 0 : ((p1[i] > p2[i]) ? 1 : -1);
                }
                else {
                    var t1 = parseInt(p1[i]);
                    var t2 = parseInt(p2[i]);

                    comp = (t1 == t2) ? 0 : ((t1 > t2) ? 1 : -1);
                }

                break;
            }
        }

        // Compares path length if both paths are equal to this point
        if (comp == 0) {
            var t1 = p1.length;
            var t2 = p2.length;

            if (t1 != t2) {
                comp = (t1 > t2) ? 1 : -1;
            }
        }

        return comp;
    }
};